package com.example.utils;

import org.apache.commons.lang3.ObjectUtils;

import java.math.BigDecimal;

import java.math.*;
import java.text.*;
import java.util.regex.*;

/**
 * 提供 BigDecimal 相关操作的工具类。
 * 包含加减乘除、精度控制等常用方法，确保数值计算的准确性。
 */
public class BigDecimalUtils {

    private static final BigDecimal hundred = new BigDecimal(100);
    private static final BigDecimal thousand = new BigDecimal(10000);

    /**
     * 去除前千分位，并保留两位小数
     * 此方法用于将带有千分位分隔符的字符串转换为保留两位小数的数字字符串
     * 主要用于财务计算等场景，确保数值的精确表示
     *
     * @param amount 带有千分位分隔符的字符串表示的数值
     * @return 转换后的保留两位小数的数字字符串
     * @throws Exception 如果输入的amount为空或无法解析为数字时抛出异常
     */
    public static String quantile(String amount) throws Exception {
        String d = "";
        // 检查输入字符串是否为空或无效
        if (BasicUtils.isEmptys(amount) != false) {
            // 创建DecimalFormat实例用于解析和格式化数字
            DecimalFormat dec = new DecimalFormat();
            // 将输入字符串解析为double类型
            double ds = dec.parse(amount).doubleValue();
            // 获取NumberFormat实例用于格式化数字
            NumberFormat nf = NumberFormat.getNumberInstance();
            // 设置格式化规则，保留两位小数
            nf.setMaximumFractionDigits(2);
            // 设置舍入模式为向上舍入
            nf.setRoundingMode(RoundingMode.UP);
            // 将格式化后的数字再次解析并转换为字符串
            d = String.valueOf(dec.parse(nf.format(ds)).doubleValue());
            // 以下为注释掉的代码，保留原逻辑以供参考
            // DecimalFormat dec = new DecimalFormat();
            // d=String.valueOf(dec.parse(amount).doubleValue());
        }
        // 返回格式化后的数字字符串
        return d;
    }


    /**
     * 转换String保留2位
     * 当输入的BigDecimal对象为null时，返回0，否则将数字保留2位小数后返回
     * 主要用途：处理财务计算等需要精确到小数点后两位的场景
     *
     * @param num 待处理的BigDecimal对象，表示一个精确的浮点数
     * @return 返回一个经过四舍五入保留两位小数后的字符串表示形式
     */
    public static String genTransString(BigDecimal num) {
        // 判断输入的BigDecimal对象是否为null
        if (num == null) {
            // 如果为null，则将其设置为0
            num = BigDecimal.ZERO;
        } else {
            // 如果不为null，则将其保留两位小数，采用四舍五入的方式
            num = num.setScale(2, BigDecimal.ROUND_HALF_UP);
        }
        // 移除结果的尾部冗余零并返回其字符串表示形式
        return num.stripTrailingZeros().toPlainString();
    }

    /**
     * 转换为亿元保留2位,返回String
     * 此方法用于将一个表示金额的BigDecimal对象转换为以亿元为单位、保留两位小数的字符串
     * 主要用于金融应用中，大额资金的显示需要以更直观的方式呈现
     *
     * @param num 表示金额的BigDecimal对象，如果为null，则默认为0
     * @return 转换后以亿元为单位、保留两位小数的字符串
     */
    public static String genMillon(BigDecimal num) {
        // 初始化null值为0，避免后续运算中的NullPointerException
        if (num == null) {
            num = BigDecimal.ZERO;
        } else {
            // 将输入的金额除以千以转换为亿元单位，并保留两位小数
            num = num.divide(thousand, 2, BigDecimal.ROUND_HALF_UP);
        }
        // 移除尾部多余的0，并将结果转换为字符串返回
        return num.stripTrailingZeros().toPlainString();
    }

    /**
     * 相除，转换为亿元保留2位,返回String
     * 这个方法用于接收两个BigDecimal数字，进行除法运算，并将结果转换为亿元为单位，
     * 保留两位小数后返回字符串表示的数值如果第二个参数为零，则返回0，
     * 否则将两个数字均除以1000后保留四位小数，再进行相除并乘以100，最终结果去除尾部无用的零后返回
     *
     * @param num1 第一个BigDecimal数字，代表被除数
     * @param num2 第二个BigDecimal数字，代表除数
     * @return 返回相除并转换为亿元后保留两位小数的字符串表示的数值
     */
    public static String genMillonTwo(BigDecimal num1, BigDecimal num2) {
        // 初始化第一个数字，如果传入为null，则设为0
        if (num1 == null) {
            num1 = BigDecimal.ZERO;
        }
        // 初始化第二个数字，如果传入为null，则设为0
        if (num2 == null) {
            num2 = BigDecimal.ZERO;
        }
        // 比较除数是否为0，避免除零错误
        if (compare(num2)) {
            // 如果除数为0，直接返回0
            return BigDecimal.ZERO.toPlainString();
        } else {
            // 将被除数和除数均除以1000，转换为亿元单位，并保留四位小数
            num1 = num1.divide(thousand, 4, BigDecimal.ROUND_HALF_UP);
            num2 = num2.divide(thousand, 4, BigDecimal.ROUND_HALF_UP);
            // 执行除法运算，结果保留两位小数，并乘以100，去除尾部无用的零后返回字符串表示的数值
            return num1.divide(num2, 2, BigDecimal.ROUND_HALF_UP).multiply(new BigDecimal(100)).stripTrailingZeros().toPlainString();
        }
    }

    /**
     * 将String类型的万元转换为亿元
     * 此方法用于处理财务数据转换，将万元单位的数值字符串转换为亿元单位的数值字符串
     *
     * @param num 万元单位的数值字符串，如果为空，则默认为0
     * @return 转换为亿元单位后的数值字符串
     */
    public static String genMillonString(String num) {
        BigDecimal bd;
        // 判断输入的数值字符串是否非空
        if (ObjectUtils.isNotEmpty(num)) {
            // 如果非空，将字符串转换为BigDecimal类型，以便进行精确计算
            bd = new BigDecimal(num);
        } else {
            // 如果为空，初始化为0，表示没有数值
            bd = BigDecimal.ZERO;
        }
        // 将BigDecimal类型的数值除以1000，保留2位小数，使用四舍五入的方式，最后移除尾部的0并转换为字符串返回
        return bd.divide(thousand, 2, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString();
    }

    /**
     * 相加之和，且四舍五入，保留两位小数
     * 此方法用于处理两个BigDecimal对象的加法运算，并确保结果保留两位小数，适用于需要高精度计算的场景
     *
     * @param num1 第一个加数，如果为null，则默认为0
     * @param num2 第二个加数，如果为null，则默认为0
     * @return 返回两个加数的和，结果四舍五入保留两位小数
     */
    public static BigDecimal genAddNum(BigDecimal num1, BigDecimal num2) {
        // 判断第一个加数是否为null，如果是，则将其设置为0，避免空指针异常
        if (num1 == null) {
            num1 = BigDecimal.ZERO;
        }
        // 判断第二个加数是否为null，如果是，则将其设置为0，避免空指针异常
        if (num2 == null) {
            num2 = BigDecimal.ZERO;
        }
        // 执行加法操作，并对结果进行四舍五入保留两位小数
        return num1.add(num2).setScale(2, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 相减之差，且四舍五入，保留两位小数
     * 该方法用于计算两个BigDecimal数字之间的差值，并将结果四舍五入到两位小数
     * 选择BigDecimal作为参数类型是因为它提供了高精度的算术运算，适合用于金融等对精度要求高的场景
     *
     * @param num1 第一个数，如果为null，则默认为0
     * @param num2 第二个数，如果为null，则默认为0
     * @return 返回两个数相减后的结果，四舍五入到两位小数
     */
    public static BigDecimal genSubtractNum(BigDecimal num1, BigDecimal num2) {
        // 检查第一个参数是否为null，如果是，则将其设置为0
        if (num1 == null) {
            num1 = BigDecimal.ZERO;
        }
        // 检查第二个参数是否为null，如果是，则将其设置为0
        if (num2 == null) {
            num2 = BigDecimal.ZERO;
        }
        // 计算两个数的差值，并将结果四舍五入到两位小数
        return num1.subtract(num2).setScale(2, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 相乘之积，且四舍五入，保留两位小数
     *
     * @param num1 第一个乘数，可以为空，如果为空则默认为0
     * @param num2 第二个乘数，可以为空，如果为空则默认为0
     * @return 返回两个乘数的乘积，结果四舍五入保留两位小数如果第二个乘数为0，则返回0
     */
    public static BigDecimal genMultiplyNum(BigDecimal num1, BigDecimal num2) {
        // 初始化第一个乘数，如果传入的值为null，则设置为0
        if (num1 == null) {
            num1 = BigDecimal.ZERO;
        }
        // 初始化第二个乘数，如果传入的值为null，则设置为0
        if (num2 == null) {
            num2 = BigDecimal.ZERO;
        }
        // 比较第二个乘数，如果为0，则直接返回0，避免后续无意义的计算
        if (compare(num2)) {
            return BigDecimal.ZERO;
        } else {
            // 两个乘数相乘，并对结果进行四舍五入保留两位小数
            return num1.multiply(num2).setScale(2, BigDecimal.ROUND_HALF_UP);
        }
    }

    /**
     * int类型数相乘，且四舍五入，保留两位小数
     * 当传入的参数为null时，将其视为0处理，以避免空指针异常
     * 若第二个数为0，则直接返回0，避免进行不必要的计算
     * 使用BigDecimal进行乘法运算，以确保精度，并进行四舍五入处理
     *
     * @param num1 第一个乘数，可以为null
     * @param num2 第二个乘数，可以为null
     * @return 乘积结果，四舍五入保留两位小数
     */
    public static BigDecimal genIntMultiplyNum(Integer num1, Integer num2) {
        // 初始化num1，若为null则设为0
        if (num1 == null) {
            num1 = 0;
        }
        // 初始化num2，若为null则设为0
        if (num2 == null) {
            num2 = 0;
        }
        // 判断num2是否为0，避免除以0的错误
        if (num2.intValue() == 0) {
            // 当num2为0时，返回0
            return BigDecimal.ZERO;
        } else {
            // 当num2不为0时，执行乘法运算并四舍五入
            return new BigDecimal(num1).multiply(new BigDecimal(num2))
                    .setScale(2, BigDecimal.ROUND_HALF_UP);
        }
    }

    /**
     * 两数相除，且四舍五入，保留两位小数
     *
     * @param num1 被除数，如果为null，则默认为0
     * @param num2 除数，如果为null，则默认为0
     * @return 如果除数为0，则返回0，否则返回两数相除的结果，四舍五入保留两位小数
     */
    public static BigDecimal genDivideNum(BigDecimal num1, BigDecimal num2) {
        // 初始化被除数，如果传入的值为null，则设为0
        if (num1 == null) {
            num1 = BigDecimal.ZERO;
        }
        // 初始化除数，如果传入的值为null，则设为0
        if (num2 == null) {
            num2 = BigDecimal.ZERO;
        }
        // 检查除数是否为0，如果为0，则返回0，避免除零错误
        if (compare(num2)) {
            return BigDecimal.ZERO;
        } else {
            // 两数相除，结果四舍五入保留两位小数
            return num1.divide(num2, 4, BigDecimal.ROUND_HALF_UP);
        }
    }

    /**
     * 两数相除，且乘100，四舍五入，保留两位小数
     *
     * @param num1 第一个BigDecimal数，代表被除数
     * @param num2 第二个BigDecimal数，代表除数
     * @return 返回计算结果，如果除数为零，则返回0
     */
    public static BigDecimal genBigDecimalNum(BigDecimal num1, BigDecimal num2) {
        // 初始化参数num1，如果传入为null，则设为0
        if (num1 == null) {
            num1 = BigDecimal.ZERO;
        }
        // 初始化参数num2，如果传入为null，则设为0
        if (num2 == null) {
            num2 = BigDecimal.ZERO;
        }
        // 检查除数是否为零，如果为零，直接返回0，避免除零错误
        if (compare(num2)) {
            return BigDecimal.ZERO;
        } else {
            // 执行除法操作，保留四位小数，然后乘以100，并再次四舍五入保留两位小数
            return num1
                    .divide(num2, 4, BigDecimal.ROUND_HALF_UP)
                    .multiply(hundred)
                    .setScale(2, BigDecimal.ROUND_HALF_UP);
        }
    }

    /**
     * 两个int类型数相除，且乘100，四舍五入，保留两位小数，最后转为String类型
     *
     * @param num1 第一个数，可以为空，将被用作除法的分子
     * @param num2 第二个数，可以为空，将被用作除法的分母
     * @return 返回格式化后的字符串，表示两个数相除并乘以100后的结果
     */
    public static String genIntToStringNum(Integer num1, Integer num2) {
        // 初始化num1，如果传入的值为null，则设为0
        if (num1 == null) {
            num1 = 0;
        }
        // 初始化num2，如果传入的值为null，则设为0
        if (num2 == null) {
            num2 = 0;
        }
        // 当分母为0时，直接返回0，避免除零错误
        if (num2.intValue() == 0) {
            return BigDecimal.ZERO.toPlainString();
        } else {
            // 执行除法操作，保留四位小数，然后乘以100，再次四舍五入保留两位小数，并去除尾部的0
            return new BigDecimal(num1)
                    .divide(new BigDecimal(num2), 4, BigDecimal.ROUND_HALF_UP)
                    .multiply(hundred)
                    .setScale(2, BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString();
        }
    }

    /**
     * 两个int类型数相除，且乘100，四舍五入，保留两位小数
     * 此方法用于处理两个整数的除法运算，并将结果以百分比的形式表示，保留两位小数
     * 主要解决了在计算百分比时可能遇到的除零问题和精度问题
     *
     * @param num1 分子，代表被除数，如果为null，则默认为0
     * @param num2 分母，代表除数，如果为null，则默认为0
     * @return 返回计算结果，以BigDecimal类型表示，四舍五入保留两位小数
     */
    public static BigDecimal genIntToBigDecimalNum(Integer num1, Integer num2) {
        // 初始化分子，默认值为0，以处理null输入
        if (num1 == null) {
            num1 = 0;
        }
        // 初始化分母，默认值为0，以处理null输入
        if (num2 == null) {
            num2 = 0;
        }
        // 检查分母是否为0，以避免除零异常
        if (num2.intValue() == 0) {
            // 如果分母为0，直接返回0，表示计算结果为0%
            return BigDecimal.ZERO;
        } else {
            // 如果分母不为0，执行除法运算，然后乘以100，最后四舍五入保留两位小数
            // 这里使用BigDecimal来处理浮点数运算，以确保精度准确
            return new BigDecimal(num1)
                    .divide(new BigDecimal(num2), 4, BigDecimal.ROUND_HALF_UP)
                    .multiply(hundred)
                    .setScale(2, BigDecimal.ROUND_HALF_UP);
        }
    }

    /**
     * 比较BigDecimal类型的数值是否与0相等
     * 由于BigDecimal类型不能直接使用==进行相等性比较，需要使用compareTo方法
     * 此方法提供了一个简单易用的接口来判断一个BigDecimal数是否等于0
     *
     * @param num 要进行比较的BigDecimal数值
     * @return 如果输入的数值与0相等，则返回true；否则返回false
     */
    public static Boolean compare(BigDecimal num) {
        // 使用compareTo方法比较输入的BigDecimal数值和BigDecimal.ZERO（即0）
        // 如果比较结果为0，则表示两者相等
        if (num.compareTo(BigDecimal.ZERO) == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 判断给定的字符串是否是有效的数字表示。
     * 该方法使用正则表达式来匹配字符串，以确定它是否符合数字的格式。
     * 数字可以是正数或负数，整数或小数。
     *
     * @param trsAmount 待检查的字符串，以判断其是否可以作为交易金额。
     * @return 如果字符串是有效的数字表示，则返回true；否则返回false。
     */
    public static boolean isNumeric(String trsAmount) {
        // 定义一个正则表达式模式，用于匹配数字
        // 该模式匹配的数字可以是正数或负数，整数或小数
        String pattern = "^[\\+\\-]?[\\d]+(\\.[\\d]+)?$";

        // 编译正则表达式模式
        Pattern r = Pattern.compile(pattern);

        // 使用编译的模式创建一个匹配器对象
        Matcher m = r.matcher(trsAmount);

        // 使用匹配器对象检查字符串是否与模式匹配
        // 如果匹配成功，返回true；否则返回false
        return m.matches();
    }

    /**
     * 加法
     * 对两个字符串表示的数字进行加法操作
     * 此方法选择使用BigDecimal来处理精确计算，避免浮点数计算的精度问题
     *
     * @param bor 第一个加数的字符串表示，可以是整数或小数
     * @param loc 第二个加数的字符串表示，可以是整数或小数
     * @return 返回加法操作后的结果，经过四舍五入处理
     */
    public static String add(String bor, String loc) {
        // 将第一个参数转换为BigDecimal类型，用于精确加法运算
        BigDecimal a1 = new BigDecimal(bor);
        // 将第二个参数转换为BigDecimal类型，用于精确加法运算
        BigDecimal b1 = new BigDecimal(loc);
        // 使用BigDecimal的add方法进行加法运算，并取其doubleValue进行四舍五入处理
        return Rounded(a1.add(b1).doubleValue());
    }

    /**
     * 执行两个数的减法操作
     * 选择使用BigDecimal来处理浮点数，以避免精度问题
     *
     * @param bor 被减数，代表较高的数值
     * @param loc 减数，代表较低的数值
     * @return 返回减法操作后的结果，经过四舍五入处理
     */
    public static String sub(String bor, String loc) {
        // 将输入字符串转换为BigDecimal类型，以进行精确的数学运算
        BigDecimal a1 = new BigDecimal(bor);
        BigDecimal b1 = new BigDecimal(loc);
        // 使用BigDecimal的subtract方法执行减法操作，并调用Rounded方法进行结果的四舍五入
        return Rounded(a1.subtract(b1).doubleValue());
    }

    /**
     * 乘法
     * 该方法接收两个字符串参数，并将它们转换为BigDecimal对象进行乘法运算
     * BigDecimal用于高精度计算，以避免浮点数计算的精度问题
     *
     * @param bor 第一个乘数
     * @param loc 第二个乘数
     * @return 返回乘法运算结果的字符串表示
     */
    public static String mul(String bor, String loc) {
        // 创建BigDecimal对象以进行精确计算
        BigDecimal a1 = new BigDecimal(bor);
        BigDecimal b1 = new BigDecimal(loc);

        // 保留2位小数
        // 以下代码被注释掉，可能是为了使用Rounded方法进行统一的格式化
        // a1.multiply(b2).setScale(2, RoundingMode.HALF_UP).doubleValue();

        // 使用Rounded方法格式化乘法运算的结果
        return Rounded(a1.multiply(b1).doubleValue());
    }

    /**
     * 执行除法操作
     *
     * @param bor 被除数，作为字符串输入以支持高精度计算
     * @param loc 除数，同样以字符串形式输入
     * @return 返回除法操作的结果，经过四舍五入处理的字符串表示
     */
    public static String div(String bor, String loc) {
        // 将输入字符串转换为BigDecimal以进行高精度除法运算
        BigDecimal a1 = new BigDecimal(bor);
        BigDecimal b1 = new BigDecimal(loc);
        // 保留2位小数
        // a1.divide(b2).setScale(2,RoundingMode.HALF_UP).doubleValue();
        // b1.divide(b2, 2,RoundingMode.HALF_UP).doubleValue();
        // 使用自定义的Rounded方法进一步处理除法结果并返回
        return Rounded(a1.divide(b1).doubleValue());
    }

    /**
     * 格式化数字字符串，去除千分位分隔符
     * 此方法用于将带有千分位分隔符的数字字符串转换为标准的数字字符串
     * 例如，将“1,234.56”转换为“1234.56”
     *
     * @param text 带有千分位分隔符的数字字符串
     * @return 转换后的数字字符串
     * @throws Exception 如果输入的字符串无法解析为数字，则抛出异常
     */
    public static String micrometer(String text) throws Exception {
        // 创建DecimalFormat实例，用于解析数字字符串
        DecimalFormat df = new DecimalFormat();
        // 使用DecimalFormat解析输入字符串为Double类型数字，自动去除千分位分隔符
        Double val = df.parse(text).doubleValue();
        // 将解析后的数字转换为字符串并返回
        return String.valueOf(val);
    }

    /**
     * 格式化数字字符串，去除千分位并保留两位小数（四舍五入）
     * 此方法用于将带有千分位的数字字符串转换为无千分位且最多两位小数的格式
     * 主要用途是处理来自传感器或特定数据源的数字字符串，使其符合特定的数据处理要求
     *
     * @param text 待格式化的数字字符串，可以包含千分位符号
     * @return 格式化后的数字字符串，不包含千分位且最多保留两位小数
     * @throws Exception 如果输入的字符串无法解析为数字，则抛出异常
     */
    public static String fmtMicrometer(String text) throws Exception {
        // 创建DecimalFormat实例，用于输出数字格式，这里指定格式为最多两位小数
        DecimalFormat df = new DecimalFormat("######.##");
        // 获取当前环境的NumberFormat实例，用于解析输入的数字字符串
        NumberFormat nf = NumberFormat.getInstance();
        // 使用NumberFormat解析输入字符串为数字，然后使用DecimalFormat格式化输出
        return df.format((nf.parse(text)));
    }

    /**
     * 比较大小
     * 比较两个字符串表示的数字的大小
     *
     * @param bor 第一个待比较的字符串表示的数字
     * @param loc 第二个待比较的字符串表示的数字
     * @return 返回比较结果的整数表示：-1表示第一个数小于第二个数，0表示两数相等，1表示第一个数大于第二个数
     */
    public static Integer isCompare(String bor, String loc) {
        // 将字符串转换为BigDecimal以进行精确比较
        BigDecimal a5 = new BigDecimal(bor);
        BigDecimal b5 = new BigDecimal(loc);
        // 使用compareTo方法比较两个BigDecimal对象的大小
        int size = a5.compareTo(b5);
        String result = "";
        // 根据比较结果设置result字符串
        if (size == -1) {
            result = "小于";
        } else if (size == 0) {
            result = "等于";
        } else if (size == 1) {
            result = "大于";
        }
        // 打印比较结果
        System.out.println(result);
        // 返回比较结果的整数表示
        return size;
    }

    /**
     * 比较两个Double类型数值的大小
     * 本方法用于比较两个Double对象的大小，并返回比较结果
     *
     * @param bor 第一个待比较的Double对象
     * @param loc 第二个待比较的Double对象
     * @return 返回比较结果的整数表示：-1表示第一个参数小于第二个参数，0表示两者相等，1表示第一个参数大于第二个参数
     */
    public static Integer isCompare(Double bor, Double loc) {
        // 使用Double的compareTo方法比较两个Double对象
        int size = bor.compareTo(loc);
        // 定义一个字符串变量用于存储比较结果的中文描述
        String result = "";
        // 根据比较结果，设置result变量的值
        if (size == -1) {
            result = "小于";
        } else if (size == 0) {
            result = "等于";
        } else if (size == 1) {
            result = "大于";
        }
        // 打印比较结果的中文描述
        System.out.println(result);
        // 返回比较结果的整数表示
        return size;
    }

    /**
     * 将输入的字符串表示的数字进行四舍五入操作
     * 此方法使用BigDecimal进行精确计算，确保数值的正确性
     *
     * @param value 待处理的数值字符串
     * @return 四舍五入后的数值字符串，保留两位小数
     */
    public static String Rounded(String value) {
        // 创建BigDecimal对象，用于精确计算
        BigDecimal number = new BigDecimal(value);
        // 设置小数点后保留两位，采用向下取整的模式
        BigDecimal tun = number.setScale(2, RoundingMode.DOWN);
        // 返回处理后的数值字符串
        return tun.toString();
    }


    /**
     * 返回未四舍五入的小数值
     * 如果小数部分少于三位，则直接返回
     * 如果小数部分多于两位，则截取前三位小数
     *
     * @param number 输入的浮点数
     * @return 根据条件格式化后的小数值字符串
     */
    public static String Rounded(Double number) {
        // 创建DecimalFormat实例，用于格式化小数
        DecimalFormat df = new DecimalFormat("#0.00");
        // 将输入的浮点数转换为字符串
        String str = Double.toString(number);
        // 查找小数点的位置
        int index = str.indexOf('.');
        // 如果存在小数点
        if (index != -1) {
            // 提取小数部分
            String result = str.substring(index + 1);
            // 如果小数部分长度大于等于2
            if (result.length() >= 2) {
                // 返回保留三位小数的字符串（不进行四舍五入）
                return str.substring(0, index + 2 + 1);
            } else {
                // 使用DecimalFormat格式化，确保两位小数
                return df.format(number);
            }
        } else {
            // 如果没有小数点，直接使用DecimalFormat格式化
            return df.format(number);
        }
    }
}

